home *** CD-ROM | disk | FTP | other *** search
/ Aminet 48 / Aminet 48 (2002)(GTI - Schatztruhe)[!][Apr 2002].iso / Aminet / util / misc / KeyMapEd.lha / KeyMapEd / Source / KME_ProcGadget.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-03-14  |  17.3 KB  |  631 lines
  1. /*
  2.  * Key Map Editor ver 1.0
  3.  * Process Gadget
  4.  *
  5.  * parameter:     Gadget - Address of Gadget selected
  6.  *
  7.  * by: Tim Friest
  8.  * on: January 1, 1989
  9.  */
  10.  
  11. #include "KME_Includes.h"
  12. #include "KME_Protos.h"
  13. #include "KME_Defs.h"
  14. #include "KME_Globals.h"
  15.  
  16. extern    int    CopyKey(struct KeyMap *, USHORT, USHORT);
  17. extern    void    MoveKey(struct KeyMap *, USHORT, USHORT);
  18. extern    void    SwapKeys(struct KeyMap *, USHORT, USHORT);
  19. extern    void    ClearKey(struct KeyMap *, USHORT);
  20.  
  21. void    ProcGadget(Gad)
  22. struct Gadget *Gad;
  23. {
  24.     int OldStatus;
  25.  
  26.     switch (Gad->GadgetID) {
  27.         case 0x60:    /* Shift Key Toggled */
  28.         case 0x61:
  29.             OldStatus = CheckFlag(SF_Shift);
  30.             if ((LeftShiftGadget.Flags & SELECTED) || (RightShiftGadget.Flags & SELECTED))
  31.                 SetFlag(SF_Shift);
  32.             else
  33.                 ClearFlag(SF_Shift);
  34.             if (OldStatus != (CheckFlag(SF_Shift)))
  35.                 UpdateDisplay(GadgetList, KeyMapNode, TRUE);
  36.             break;
  37.         case 0x62:    /* Caps Lock Key Toggled */
  38.             OldStatus = CheckFlag(SF_CapsLock);
  39.             if (Gad->Flags & SELECTED)
  40.                 SetFlag(SF_CapsLock);
  41.             else
  42.                 ClearFlag(SF_CapsLock);
  43.             if (!(CheckFlag(SF_Shift)) && (OldStatus != (CheckFlag(SF_CapsLock))))
  44.                 UpdateDisplay(GadgetList, KeyMapNode, TRUE);
  45.             break;
  46.         case 0x63:    /* Control Key Toggled */
  47.             OldStatus = CheckFlag(SF_Control);
  48.             if (Gad->Flags & SELECTED)
  49.                 SetFlag(SF_Control);
  50.             else
  51.                 ClearFlag(SF_Control);
  52.             if (OldStatus != (CheckFlag(SF_Control)))
  53.                 UpdateDisplay(GadgetList, KeyMapNode, TRUE);
  54.             break;
  55.         case 0x64:    /* Alt Key Toggled */
  56.         case 0x65:
  57.             OldStatus = CheckFlag(SF_Alt);
  58.             if ((LeftAltGadget.Flags & SELECTED) || (RightAltGadget.Flags & SELECTED))
  59.                 SetFlag(SF_Alt);
  60.             else
  61.                 ClearFlag(SF_Alt);
  62.             if (OldStatus != (CheckFlag(SF_Alt)))
  63.                 UpdateDisplay(GadgetList, KeyMapNode, TRUE);
  64.             break;
  65.         default:
  66.             switch (StatusFlags & (SF_Define|SF_Copy|SF_Move|SF_Swap|SF_Clear)) {
  67.                 case SF_Define:
  68.                     if (ProcKeyReq(Gad->GadgetID))
  69.                         UpdateDisplay(Gad, KeyMapNode, FALSE);
  70.                     break;
  71.                 case SF_Copy:
  72.                     if (FromKeyGad == NULL) {
  73.                         FromKeyGad = Gad;
  74.                         ChangePointer(-1);
  75.                     }
  76.                     else {
  77.                         if (FromKeyGad != Gad) {
  78.                             CopyKey(&KeyMapNode->kn_KeyMap, FromKeyGad->GadgetID, Gad->GadgetID);
  79.                             UpdateDisplay(Gad, KeyMapNode, FALSE);
  80.                         }
  81.                         ChangePointer(SF_Copy);
  82.                         FromKeyGad = NULL;
  83.                     }
  84.                     break;
  85.                 case SF_Move:
  86.                     if (FromKeyGad == NULL) {
  87.                         FromKeyGad = Gad;
  88.                         ChangePointer(-1);
  89.                     }
  90.                     else {
  91.                         if (FromKeyGad != Gad) {
  92.                             MoveKey(&KeyMapNode->kn_KeyMap, FromKeyGad->GadgetID, Gad->GadgetID);
  93.                             UpdateDisplay(FromKeyGad, KeyMapNode, FALSE);
  94.                             UpdateDisplay(Gad, KeyMapNode, FALSE);
  95.                         }
  96.                         ChangePointer(SF_Move);
  97.                         FromKeyGad = NULL;
  98.                     }
  99.                     break;
  100.                 case SF_Swap:
  101.                     if (FromKeyGad == NULL) {
  102.                         FromKeyGad = Gad;
  103.                         ChangePointer(-1);
  104.                     }
  105.                     else {
  106.                         if (FromKeyGad != Gad) {
  107.                             SwapKeys(&KeyMapNode->kn_KeyMap, FromKeyGad->GadgetID, Gad->GadgetID);
  108.                             UpdateDisplay(FromKeyGad, KeyMapNode, FALSE);
  109.                             UpdateDisplay(Gad, KeyMapNode, FALSE);
  110.                         }
  111.                         ChangePointer(SF_Swap);
  112.                         FromKeyGad = NULL;
  113.                     }
  114.                     break;
  115.                 case SF_Clear:
  116.                     ClearKey(&KeyMapNode->kn_KeyMap, Gad->GadgetID);
  117.                     UpdateDisplay(Gad, KeyMapNode, FALSE);
  118.             } /* switch */
  119.     } /* switch */
  120. }
  121.  
  122. /*
  123.  * Copy Key
  124.  *
  125.  * Parameters:    KeyMap - KeyMap to work with
  126.  *        FromKeyCode - Key Code to copy from
  127.  *        ToKeyCode - Key Code to copy to
  128.  */
  129. int CopyKey(KeyMap, FromKey, ToKey)
  130. struct KeyMap *KeyMap;
  131. unsigned short FromKey;
  132. unsigned short ToKey;
  133. {
  134.     struct HalfKeyMap *FromHalfKeyMap, *ToHalfKeyMap;
  135.     int len;
  136.     UBYTE headerlen;
  137.  
  138.     if (FromKey < 0x40)
  139.         FromHalfKeyMap = (struct HalfKeyMap *)KeyMap;
  140.     else {
  141.         FromHalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
  142.         FromKey -= 0x40;
  143.     }
  144.     if (ToKey < 0x40)
  145.         ToHalfKeyMap = (struct HalfKeyMap *)KeyMap;
  146.     else {
  147.         ToHalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
  148.         ToKey -= 0x40;
  149.     }
  150.  
  151.     switch (FromHalfKeyMap->KeyMapTypes[FromKey] & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
  152.         case KC_NOQUAL:
  153.         case KCF_NOP:
  154.             ToHalfKeyMap->KeyMap[ToKey] = FromHalfKeyMap->KeyMap[FromKey];
  155.             break;
  156.         case KCF_STRING:
  157.             len = StringKeyLength(FromHalfKeyMap, FromKey, &headerlen);
  158.             if ((ToHalfKeyMap->KeyMap[ToKey] = (ULONG)AllocMem(len, MEMF_CLEAR)) == NULL) {
  159.                 Write(Output(), "Memory Allocation Failed, CopyKey:String\n", 41);
  160.                 return(FALSE);
  161.             }
  162.             CopyStringKey(FromHalfKeyMap, FromKey, (UBYTE *)ToHalfKeyMap->KeyMap[ToKey], headerlen);
  163.             break;
  164.         case KCF_DEAD:
  165.             len = DeadKeyLength(FromHalfKeyMap, FromKey, &headerlen);
  166.             if ((ToHalfKeyMap->KeyMap[ToKey] = (ULONG)AllocMem(len, MEMF_CLEAR)) == NULL) {
  167.                 Write(Output(), "Memory Allocation Failed, CopyKey:Dead\n", 39);
  168.                 return(FALSE);
  169.             }
  170.             CopyDeadKey(FromHalfKeyMap, FromKey, (UBYTE *)ToHalfKeyMap->KeyMap[ToKey], headerlen);
  171.     } /* switch */
  172.     ToHalfKeyMap->KeyMapTypes[ToKey] = FromHalfKeyMap->KeyMapTypes[FromKey];
  173.     ToHalfKeyMap->Capsable[ToKey/8] &= ~(ToKey % 8);
  174.     ToHalfKeyMap->Capsable[ToKey/8] |= (FromHalfKeyMap->Capsable[FromKey/8] & (FromKey % 8));
  175.     ToHalfKeyMap->Repeatable[ToKey/8] &= ~(ToKey % 8);
  176.     ToHalfKeyMap->Repeatable[ToKey/8] |= (FromHalfKeyMap->Repeatable[FromKey/8] & (FromKey % 8));
  177.     SetFlag(SF_Modified);
  178.     return(TRUE);
  179. }
  180.  
  181. /*
  182.  * Move Key
  183.  *
  184.  * Parameters:    KeyMap - KeyMap to work with
  185.  *        FromKeyCode - Key Code to move from
  186.  *        ToKeyCode - Key Code to move to
  187.  */
  188. void MoveKey(KeyMap, FromKey, ToKey)
  189. struct KeyMap *KeyMap;
  190. unsigned short FromKey;
  191. unsigned short ToKey;
  192. {
  193.     struct HalfKeyMap *FromHalfKeyMap, *ToHalfKeyMap;
  194.  
  195.     if (FromKey < 0x40)
  196.         FromHalfKeyMap = (struct HalfKeyMap *)KeyMap;
  197.     else {
  198.         FromHalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
  199.         FromKey -= 0x40;
  200.     }
  201.     if (ToKey < 0x40)
  202.         ToHalfKeyMap = (struct HalfKeyMap *)KeyMap;
  203.     else {
  204.         ToHalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
  205.         ToKey -= 0x40;
  206.     }
  207.  
  208.     ToHalfKeyMap->KeyMapTypes[ToKey] = FromHalfKeyMap->KeyMapTypes[FromKey];
  209.     ToHalfKeyMap->KeyMap[ToKey] = FromHalfKeyMap->KeyMap[FromKey];
  210.     ToHalfKeyMap->Capsable[ToKey/8] &= ~(ToKey % 8);
  211.     ToHalfKeyMap->Capsable[ToKey/8] |= (FromHalfKeyMap->Capsable[FromKey/8] & (FromKey % 8));
  212.     ToHalfKeyMap->Repeatable[ToKey/8] &= ~(ToKey % 8);
  213.     ToHalfKeyMap->Repeatable[ToKey/8] |= (FromHalfKeyMap->Repeatable[FromKey/8] & (FromKey % 8));
  214.  
  215.     FromHalfKeyMap->KeyMapTypes[FromKey] = KCF_NOP;
  216.     FromHalfKeyMap->KeyMap[FromKey] = NULL;
  217.     FromHalfKeyMap->Capsable[FromKey/8] &= ~(FromKey % 8);
  218.     FromHalfKeyMap->Repeatable[FromKey/8] &= ~(FromKey % 8);
  219.     SetFlag(SF_Modified);
  220. }
  221.  
  222. /*
  223.  * Swap Key
  224.  *
  225.  * Parameters:    KeyMap - KeyMap to work with
  226.  *        FromKeyCode - Key Code to swap from
  227.  *        ToKeyCode - Key Code to swap to
  228.  */
  229. void SwapKeys(KeyMap, FromKey, ToKey)
  230. struct KeyMap *KeyMap;
  231. unsigned short FromKey;
  232. unsigned short ToKey;
  233. {
  234.     struct HalfKeyMap *FromHalfKeyMap, *ToHalfKeyMap;
  235.     UBYTE temptype, tempcaps, temprepeat;
  236.     ULONG tempmap;
  237.  
  238.     if (FromKey < 0x40)
  239.         FromHalfKeyMap = (struct HalfKeyMap *)KeyMap;
  240.     else {
  241.         FromHalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
  242.         FromKey -= 0x40;
  243.     }
  244.     if (ToKey < 0x40)
  245.         ToHalfKeyMap = (struct HalfKeyMap *)KeyMap;
  246.     else {
  247.         ToHalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
  248.         ToKey -= 0x40;
  249.     }
  250.  
  251.     temptype = ToHalfKeyMap->KeyMapTypes[ToKey];
  252.     tempmap = ToHalfKeyMap->KeyMap[ToKey];
  253.     tempcaps = ToHalfKeyMap->Capsable[ToKey/8] & (ToKey % 8);
  254.     temprepeat = ToHalfKeyMap->Repeatable[ToKey/8] & (ToKey % 8);
  255.  
  256.     ToHalfKeyMap->KeyMapTypes[ToKey] = FromHalfKeyMap->KeyMapTypes[FromKey];
  257.     ToHalfKeyMap->KeyMap[ToKey] = FromHalfKeyMap->KeyMap[FromKey];
  258.     ToHalfKeyMap->Capsable[ToKey/8] &= ~(ToKey % 8);
  259.     ToHalfKeyMap->Capsable[ToKey/8] |= (FromHalfKeyMap->Capsable[FromKey/8] & (FromKey % 8));
  260.     ToHalfKeyMap->Repeatable[ToKey/8] &= ~(ToKey % 8);
  261.     ToHalfKeyMap->Repeatable[ToKey/8] |= (FromHalfKeyMap->Repeatable[FromKey/8] & (FromKey % 8));
  262.  
  263.     FromHalfKeyMap->KeyMapTypes[FromKey] = temptype;
  264.     FromHalfKeyMap->KeyMap[FromKey] = tempmap;
  265.     FromHalfKeyMap->Capsable[FromKey/8] &= ~(FromKey % 8);
  266.     FromHalfKeyMap->Capsable[FromKey/8] |= tempcaps;
  267.     FromHalfKeyMap->Repeatable[FromKey/8] &= ~(FromKey % 8);
  268.     FromHalfKeyMap->Repeatable[FromKey/8] |= temprepeat;
  269.     SetFlag(SF_Modified);
  270. }
  271.  
  272. /*
  273.  * Clear Key
  274.  *
  275.  * parameters:    KeyMap - Key Map to work with
  276.  *        KeyCode - KeyCode to erase
  277.  */
  278. void ClearKey(KeyMap, KeyCode)
  279. struct KeyMap *KeyMap;
  280. unsigned short KeyCode;
  281. {
  282.     struct HalfKeyMap *HalfKeyMap;
  283.     int len;
  284.     UBYTE headerlen;
  285.  
  286.     if (KeyCode < 0x40)
  287.         HalfKeyMap = (struct HalfKeyMap *)KeyMap;
  288.     else {
  289.         HalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
  290.         KeyCode -= 0x40;
  291.     }
  292.  
  293.     switch (HalfKeyMap->KeyMapTypes[KeyCode] & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
  294.         case KCF_STRING:
  295.             len = StringKeyLength(HalfKeyMap, KeyCode, &headerlen);
  296.             FreeMem((UBYTE *)HalfKeyMap->KeyMap[KeyCode], len);
  297.             break;
  298.         case KCF_DEAD:
  299.             len = DeadKeyLength(HalfKeyMap, KeyCode, &headerlen);
  300.             FreeMem((UBYTE *)HalfKeyMap->KeyMap[KeyCode], len);
  301.     } /* switch */
  302.     HalfKeyMap->KeyMap[KeyCode] = NULL;
  303.     HalfKeyMap->KeyMapTypes[KeyCode] = KCF_NOP;
  304.     HalfKeyMap->Capsable[KeyCode/8] &= ~(KeyCode % 8);
  305.     HalfKeyMap->Repeatable[KeyCode/8] &= ~(KeyCode % 8);
  306.     SetFlag(SF_Modified);
  307. }
  308.  
  309. /*
  310.  * String Key Length
  311.  *
  312.  * parameters:    HalfKeyMap - half of a key map structure
  313.  *        KeyCode - Key Code
  314.  *        HeaderLen - Location to place header length
  315.  *
  316.  * returns:    Length - length of key buffer
  317.  */
  318. UBYTE StringKeyLength(HalfKeyMap, KeyCode, HeaderLength)
  319. struct HalfKeyMap *HalfKeyMap;
  320. USHORT KeyCode;
  321. UBYTE *HeaderLength;
  322. {
  323.     UBYTE KeyType;
  324.     UBYTE *KeyMapPtr;
  325.     UBYTE len, index;
  326.  
  327.     KeyType = HalfKeyMap->KeyMapTypes[KeyCode];
  328.     KeyMapPtr = (UBYTE *)HalfKeyMap->KeyMap[KeyCode];
  329.  
  330.     len = 2 + KeyMapPtr[index = 0];
  331.     if (KeyType & KCF_SHIFT)
  332.         len += 2 + KeyMapPtr[index += 2];
  333.     if (KeyType & KCF_ALT)
  334.         len += 2 + KeyMapPtr[index += 2];
  335.     if ((KeyType & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
  336.         len += 2 + KeyMapPtr[index += 2];
  337.     if (KeyType & KCF_CONTROL)
  338.         len += 2 + KeyMapPtr[index += 2];
  339.     if ((KeyType & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
  340.         len += 2 + KeyMapPtr[index += 2];
  341.     if ((KeyType & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
  342.         len += 2 + KeyMapPtr[index += 2];
  343.     if ((KeyType & KC_VANILLA) == KC_VANILLA)
  344.         len += 2 + KeyMapPtr[index += 2];
  345.     *HeaderLength = index + 2;
  346.     return(len);
  347. }
  348.  
  349. /*
  350.  * Copy String Key
  351.  *
  352.  * parameters:    HalfKeyMap - Half of a key map
  353.  *        KeyCode - Key Code
  354.  *        KeyBuff - location to place key data
  355.  *        Header - length of key data header
  356.  *
  357.  * returns:    Length - length copied
  358.  */
  359. UBYTE CopyStringKey(HalfKeyMap, KeyCode, KeyBuff, HeaderLength)
  360. struct HalfKeyMap *HalfKeyMap;
  361. USHORT KeyCode;
  362. UBYTE *KeyBuff;
  363. UBYTE HeaderLength;
  364. {
  365.     UBYTE KeyType;
  366.     UBYTE *KeyMapPtr;
  367.     UBYTE len, index;
  368.  
  369.     KeyType = HalfKeyMap->KeyMapTypes[KeyCode];
  370.     KeyMapPtr = (UBYTE *)HalfKeyMap->KeyMap[KeyCode];
  371.  
  372.     len = HeaderLength;
  373.     KeyBuff[index = 0] = KeyMapPtr[index];
  374.     KeyBuff[index+1] = len;
  375.     memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
  376.     len += KeyBuff[index];
  377.     if (KeyType & KCF_SHIFT) {
  378.         KeyBuff[index += 2] = KeyMapPtr[index];
  379.         KeyBuff[index+1] = len;
  380.         memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
  381.         len += KeyBuff[index];
  382.     }
  383.     if (KeyType & KCF_ALT) {
  384.         KeyBuff[index += 2] = KeyMapPtr[index];
  385.         KeyBuff[index+1] = len;
  386.         memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
  387.         len += KeyBuff[index];
  388.     }
  389.     if ((KeyType & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT)) {
  390.         KeyBuff[index += 2] = KeyMapPtr[index];
  391.         KeyBuff[index+1] = len;
  392.         memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
  393.         len += KeyBuff[index];
  394.     }
  395.     if (KeyType & KCF_CONTROL) {
  396.         KeyBuff[index += 2] = KeyMapPtr[index];
  397.         KeyBuff[index+1] = len;
  398.         memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
  399.         len += KeyBuff[index];
  400.     }
  401.     if ((KeyType & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT)) {
  402.         KeyBuff[index += 2] = KeyMapPtr[index];
  403.         KeyBuff[index+1] = len;
  404.         memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
  405.         len += KeyBuff[index];
  406.     }
  407.     if ((KeyType & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT)) {
  408.         KeyBuff[index += 2] = KeyMapPtr[index];
  409.         KeyBuff[index+1] = len;
  410.         memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
  411.         len += KeyBuff[index];
  412.     }
  413.     if ((KeyType & KC_VANILLA) == KC_VANILLA) {
  414.         KeyBuff[index += 2] = KeyMapPtr[index];
  415.         KeyBuff[index+1] = len;
  416.         memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
  417.         len += KeyBuff[index];
  418.     }
  419.     return(len);
  420. }
  421.  
  422. /*
  423.  * Dead Key Length
  424.  *
  425.  * parameters:    HalfKeyMap - half of a key map structure
  426.  *        KeyCode - Key Code
  427.  *        HeaderLength - Location to place header length
  428.  *
  429.  * returns:    Length - length of key buffer
  430.  */
  431. UBYTE DeadKeyLength(HalfKeyMap, KeyCode, HeaderLength)
  432. struct HalfKeyMap *HalfKeyMap;
  433. USHORT KeyCode;
  434. UBYTE *HeaderLength;
  435. {
  436.     UBYTE KeyType;
  437.     UBYTE *KeyMapPtr;
  438.     UBYTE len, index;
  439.  
  440.     KeyType = HalfKeyMap->KeyMapTypes[KeyCode];
  441.     KeyMapPtr = (UBYTE *)HalfKeyMap->KeyMap[KeyCode];
  442.     
  443.     switch (KeyMapPtr[index = 0]) {
  444.         case KC_NOQUAL:
  445.         case DPF_DEAD:
  446.             len = 2;
  447.             break;
  448.         case DPF_MOD:
  449.             len = 2 + 6;
  450.     } /* switch */
  451.     if (KeyType & KCF_SHIFT)
  452.         switch (KeyMapPtr[index += 2]) {
  453.             case KC_NOQUAL:
  454.             case DPF_DEAD:
  455.                 len += 2;
  456.                 break;
  457.             case DPF_MOD:
  458.                 len += 2 + 6;
  459.         } /* switch */
  460.     if (KeyType & KCF_ALT)
  461.         switch (KeyMapPtr[index += 2]) {
  462.             case KC_NOQUAL:
  463.             case DPF_DEAD:
  464.                 len += 2;
  465.                 break;
  466.             case DPF_MOD:
  467.                 len += 2 + 6;
  468.         } /* switch */
  469.     if ((KeyType & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
  470.         switch (KeyMapPtr[index += 2]) {
  471.             case KC_NOQUAL:
  472.             case DPF_DEAD:
  473.                 len += 2;
  474.                 break;
  475.             case DPF_MOD:
  476.                 len += 2 + 6;
  477.         } /* switch */
  478.     if (KeyType & KCF_CONTROL)
  479.         switch (KeyMapPtr[index += 2]) {
  480.             case KC_NOQUAL:
  481.             case DPF_DEAD:
  482.                 len += 2;
  483.                 break;
  484.             case DPF_MOD:
  485.                 len += 2 + 6;
  486.         } /* switch */
  487.     if ((KeyType & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
  488.         switch (KeyMapPtr[index += 2]) {
  489.             case KC_NOQUAL:
  490.             case DPF_DEAD:
  491.                 len += 2;
  492.                 break;
  493.             case DPF_MOD:
  494.                 len += 2 + 6;
  495.         } /* switch */
  496.     if ((KeyType & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
  497.         switch (KeyMapPtr[index += 2]) {
  498.             case KC_NOQUAL:
  499.             case DPF_DEAD:
  500.                 len += 2;
  501.                 break;
  502.             case DPF_MOD:
  503.                 len += 2 + 6;
  504.         } /* switch */
  505.     if ((KeyType & KC_VANILLA) == KC_VANILLA)
  506.         switch (KeyMapPtr[index += 2]) {
  507.             case KC_NOQUAL:
  508.             case DPF_DEAD:
  509.                 len += 2;
  510.                 break;
  511.             case DPF_MOD:
  512.                 len += 2 + 6;
  513.         } /* switch */
  514.     *HeaderLength = index + 2;
  515.     return(len);
  516. }
  517.  
  518. /*
  519.  * Copy Dead Key
  520.  *
  521.  * parameters:    HalfKeyMap - Half of a key map
  522.  *        KeyCode - Key Code
  523.  *        KeyBuff - location to place key data
  524.  *        HeaderLength - length of key data header
  525.  *
  526.  * returns:    Length - length copied
  527.  */
  528. UBYTE CopyDeadKey(HalfKeyMap, KeyCode, KeyBuff, HeaderLength)
  529. struct HalfKeyMap *HalfKeyMap;
  530. USHORT KeyCode;
  531. UBYTE *KeyBuff;
  532. UBYTE HeaderLength;
  533. {
  534.     UBYTE KeyType;
  535.     UBYTE *KeyMapPtr;
  536.     UBYTE len, index;
  537.  
  538.     KeyType = HalfKeyMap->KeyMapTypes[KeyCode];
  539.     KeyMapPtr = (UBYTE *)HalfKeyMap->KeyMap[KeyCode];
  540.  
  541.     len = HeaderLength;    
  542.     switch (KeyBuff[index = 0] = KeyMapPtr[index]) {
  543.         case KC_NOQUAL:
  544.         case DPF_DEAD:
  545.             KeyBuff[index+1] = KeyMapPtr[index+1];
  546.             break;
  547.         case DPF_MOD:
  548.             KeyBuff[index+1] = len;
  549.             memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
  550.             len += 6;
  551.     } /* switch */
  552.     if (KeyType & KCF_SHIFT)
  553.         switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
  554.             case KC_NOQUAL:
  555.             case DPF_DEAD:
  556.                 KeyBuff[index+1] = KeyMapPtr[index+1];
  557.                 break;
  558.             case DPF_MOD:
  559.                 KeyBuff[index+1] = len;
  560.                 memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
  561.                 len += 6;
  562.         } /* switch */
  563.     if (KeyType & KCF_ALT)
  564.         switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
  565.             case KC_NOQUAL:
  566.             case DPF_DEAD:
  567.                 KeyBuff[index+1] = KeyMapPtr[index+1];
  568.                 break;
  569.             case DPF_MOD:
  570.                 KeyBuff[index+1] = len;
  571.                 memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
  572.                 len += 6;
  573.         } /* switch */
  574.     if ((KeyType & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
  575.         switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
  576.             case KC_NOQUAL:
  577.             case DPF_DEAD:
  578.                 KeyBuff[index+1] = KeyMapPtr[index+1];
  579.                 break;
  580.             case DPF_MOD:
  581.                 KeyBuff[index+1] = len;
  582.                 memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
  583.                 len += 6;
  584.         } /* switch */
  585.     if (KeyType & KCF_CONTROL)
  586.         switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
  587.             case KC_NOQUAL:
  588.             case DPF_DEAD:
  589.                 KeyBuff[index+1] = KeyMapPtr[index+1];
  590.                 break;
  591.             case DPF_MOD:
  592.                 KeyBuff[index+1] = len;
  593.                 memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
  594.                 len += 6;
  595.         } /* switch */
  596.     if ((KeyType & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
  597.         switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
  598.             case KC_NOQUAL:
  599.             case DPF_DEAD:
  600.                 KeyBuff[index+1] = KeyMapPtr[index+1];
  601.                 break;
  602.             case DPF_MOD:
  603.                 KeyBuff[index+1] = len;
  604.                 memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
  605.                 len += 6;
  606.         } /* switch */
  607.     if ((KeyType & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
  608.         switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
  609.             case KC_NOQUAL:
  610.             case DPF_DEAD:
  611.                 KeyBuff[index+1] = KeyMapPtr[index+1];
  612.                 break;
  613.             case DPF_MOD:
  614.                 KeyBuff[index+1] = len;
  615.                 memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
  616.                 len += 6;
  617.         } /* switch */
  618.     if ((KeyType & KC_VANILLA) == KC_VANILLA)
  619.         switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
  620.             case KC_NOQUAL:
  621.             case DPF_DEAD:
  622.                 KeyBuff[index+1] = KeyMapPtr[index+1];
  623.                 break;
  624.             case DPF_MOD:
  625.                 KeyBuff[index+1] = len;
  626.                 memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
  627.                 len += 6;
  628.         } /* switch */
  629.     return(len);
  630. }
  631.